import type { ErrorMessageMode } from '#/axios';
import { defineStore } from 'pinia';
import { store } from '@/store';
import { PageEnum } from '@/enums/pageEnum';
import { PermissionModeEnum } from '@/enums/appEnum';
import { ROLES_KEY, ACCESS_TOKEN_KEY, TOKEN_KEY, USER_INFO_KEY } from '@/enums/cacheEnum';
import {
  token,
  phoneToken,
  authorizationToken,
  setOrganization,
  checkLogin,
  logout,
  profile,
  profileEdit,
  changePassword,
  changeUserEmail,
  changeUserPhone,
} from '@/api/identity';
import {
  TokenDto,
  LoginDto,
  PhoneTokenDto,
  AuthorizationTokenDto,
  JsonWebToken,
  UserInfo,
  ProfileEditDto,
  ChangePasswordDto,
  EmailEditDto,
  PhoneEditDto,
} from '@/api/identity/model';
import { getAuthInfo } from '@/api/authorization';
import { getAuthCache, setAuthCache, removeAuthCache } from '@/utils/auth';
import { useMessage } from '@/hooks/web/useMessage';

import { router } from '@/router';
import headerImg from '@/assets/images/header.png';
import { setPreferenceInfo, removePreferenceInfo } from '@/utils/preference';
import { ExchangeQuotationEnum } from '@/enums/exchangeQuotationEnum';
import { usePermissionStore } from '@/store/modules/permission';
import { useAppStore } from '@/store/modules/app';
import { usePermission } from '@/hooks/web/usePermission';
import { RouteRecordRaw } from 'vue-router';
import { PAGE_NOT_FOUND_ROUTE } from '@/router/routes/basic';

import * as signalR from '@microsoft/signalr';
import { useGlobSetting } from '@/hooks/setting';

/** 身份状态 */
interface IdentityState {
  /** 用户信息 */
  userInfo: Nullable<UserInfo>;
  /** 访问令牌 */
  accessToken?: string;
  /** JwtToken对象 */
  jsonWebToken: Nullable<JsonWebToken>;
  /** 角色列表 */
  roleList: string[];
  /** 登录是否过期 */
  sessionTimeout?: boolean;
  /** 最后刷新时间 */
  lastUpdateTime: number;
  /** SignalR集线器的连接 */
  signalrHub: Nullable<signalR.HubConnection>;
}

/** 使用身份认证存储 */
export const useIdentityStore = defineStore({
  /** 编号 */
  id: 'app-identity',
  state: (): IdentityState => ({
    /** 用户信息 */
    userInfo: null,
    /** 访问令牌 */
    accessToken: undefined,
    /** JwtToken对象 */
    jsonWebToken: null,
    /** 角色列表 */
    roleList: [],
    /** 登录是否过期 */
    sessionTimeout: false,
    /** 最后刷新时间 */
    lastUpdateTime: 0,
    /** SignalR集线器的连接 */
    signalrHub: null,
  }),
  /** 获取器 */
  getters: {
    /** 获取用户信息 */
    getUserInfo(state): UserInfo {
      return state.userInfo || getAuthCache<UserInfo>(USER_INFO_KEY) || {};
    },
    /** 获取AccessToken */
    getAccessToken(state): string {
      return state.accessToken || getAuthCache<string>(ACCESS_TOKEN_KEY);
    },
    /** 获取JwtToken对象 */
    getToken(state): JsonWebToken {
      return state.jsonWebToken || getAuthCache<JsonWebToken>(TOKEN_KEY) || {};
    },
    /** 获取角色列表 */
    getRoleList(state): string[] {
      const cacheRoleList = getAuthCache<string[]>(ROLES_KEY);
      return state.roleList.length > 0 ? state.roleList : cacheRoleList;
    },
    /** 获取登录是否过期 */
    getSessionTimeout(state): boolean {
      return !!state.sessionTimeout;
    },
    /** 获取最后刷新时间 */
    getLastUpdateTime(state): number {
      return state.lastUpdateTime;
    },
    /** 获取SignalR集线器的连接 */
    getSignalRHub(state): signalR.HubConnection {
      return state.signalrHub as signalR.HubConnection;
    },
  },
  /** 方法 */
  actions: {
    /** 设置用户信息 */
    setUserInfo(userInfo: UserInfo | null) {
      // removeAuthCache(USER_INFO_KEY);
      this.userInfo = userInfo;
      this.lastUpdateTime = new Date().getTime();
      setAuthCache(USER_INFO_KEY, userInfo);
    },
    /**
     * 设置JwtToken
     * @param jsonWebToken JwtToken模型
     */
    async setToken(jsonWebToken: JsonWebToken | undefined) {
      if (jsonWebToken !== undefined && jsonWebToken !== null) {
        this.accessToken = jsonWebToken.AccessToken;
        setAuthCache(ACCESS_TOKEN_KEY, jsonWebToken.AccessToken);
        // let seconds = BigInt(new Date().valueOf());
        // seconds = Math.round((jsonWebToken.RefreshTokenExpiresUtc - seconds) / 1000n);
        let seconds = new Date().valueOf();
        const accessTokenExpiresUtc = jsonWebToken.AccessTokenExpiresUtc
          ? Number(jsonWebToken.AccessTokenExpiresUtc)
          : 0;
        seconds = (accessTokenExpiresUtc - seconds) / 1000;
        if (seconds > 0) {
          this.jsonWebToken = jsonWebToken;
          setAuthCache(TOKEN_KEY, jsonWebToken);
          // ls.set(TOKEN_KEY, jsonWebToken.RefreshToken, seconds);
        }
        await this.refreshUser();
      } else {
        await this.resetState();
      }
    },
    /** 设置角色列表 */
    setRoleList(roleList: string[]) {
      // removeAuthCache(ROLES_KEY);
      this.roleList = roleList;
      setAuthCache(ROLES_KEY, roleList);
    },
    /** 设置登录是否过期 */
    setSessionTimeout(flag: boolean) {
      this.sessionTimeout = flag;
    },
    /** 重置状态 */
    async resetState() {
      this.accessToken = '';
      removeAuthCache(ACCESS_TOKEN_KEY);

      this.jsonWebToken = null;
      removeAuthCache(TOKEN_KEY);

      this.userInfo = null;
      removeAuthCache(USER_INFO_KEY);

      // this.setRoleList([]);
      this.roleList = [];
      removeAuthCache(ROLES_KEY);

      this.sessionTimeout = false;
      // this.setSessionTimeout(false);

      removePreferenceInfo();
      await this.refreshUser();
      await this.disconnectSignalRHub();
    },
    /**
     * @description: 登录（login）
     */
    async login(
      params: TokenDto & {
        goHome?: boolean;
        mode?: ErrorMessageMode;
      },
    ): Promise<UserInfo | null> {
      try {
        const { goHome = true, mode, ...loginParams } = params;
        const ajaxResult = await token(loginParams, mode);
        if (ajaxResult.Data !== undefined && ajaxResult.Data !== null && ajaxResult.Data) {
          const jsonWebToken = ajaxResult.Data as JsonWebToken;
          await this.loginEnd(jsonWebToken);

          return await this.afterLoginAction(goHome);
        }
        return null;
      } catch (error) {
        return Promise.reject(error);
      }
    },
    /**
     * @description: 使用手机号码登录
     */
    async phoneLogin(
      params: PhoneTokenDto & {
        goHome?: boolean;
        mode?: ErrorMessageMode;
      },
    ): Promise<UserInfo | null> {
      try {
        const { goHome = true, mode, ...loginParams } = params;
        const ajaxResult = await phoneToken(loginParams, mode);
        if (ajaxResult.Data !== undefined && ajaxResult.Data !== null && ajaxResult.Data) {
          const jsonWebToken = ajaxResult.Data as JsonWebToken;
          await this.loginEnd(jsonWebToken);

          return await this.afterLoginAction(goHome);
        }
        return null;
      } catch (error) {
        return Promise.reject(error);
      }
    },
    /**
     * @description: 使用授权码登录
     */
    async authorizationLogin(
      params: AuthorizationTokenDto & {
        goHome?: boolean;
        mode?: ErrorMessageMode;
      },
    ): Promise<UserInfo | null> {
      try {
        const { goHome = true, mode, ...loginParams } = params;
        const ajaxResult = await authorizationToken(loginParams, mode);
        if (ajaxResult.Data !== undefined && ajaxResult.Data !== null && ajaxResult.Data) {
          const jsonWebToken = ajaxResult.Data as JsonWebToken;
          await this.loginEnd(jsonWebToken);

          return await this.afterLoginAction(goHome);
        }
        return null;
      } catch (error) {
        return Promise.reject(error);
      }
    },
    /**
     * @description: 设置当前组织机构
     */
    async setOrganization(
      params: { organizationId: string } & {
        mode?: ErrorMessageMode;
      },
    ): Promise<UserInfo | null> {
      const { mode, ...setOrganizationParams } = params;
      const ajaxResult = await setOrganization(setOrganizationParams.organizationId, mode);
      if (ajaxResult.Data !== undefined && ajaxResult.Data !== null && ajaxResult.Data) {
        const jsonWebToken = ajaxResult.Data as JsonWebToken;
        await this.loginEnd(jsonWebToken);

        return await this.afterLoginAction(false);
      }
      return null;
    },
    /**
     * @description: 验证登录（Check Login）
     */
    async checkLogin(
      params: LoginDto & {
        goHome?: boolean;
        mode?: ErrorMessageMode;
      },
    ) {
      const { goHome = true, mode = 'none', ...loginParams } = params;
      const ajaxResult = await checkLogin(loginParams, mode);
      if (ajaxResult.Succeeded) {
        await this.afterLoginAction(goHome);
      }
      return ajaxResult;
    },
    /**
     * 登录后操作
     * @param goHome 是否返回主页
     * @returns 用户信息
     */
    async afterLoginAction(goHome?: boolean): Promise<UserInfo | null> {
      if (!this.getAccessToken) return null;
      // get user info
      const userInfo = await this.getUserInfoAction();

      const sessionTimeout = this.sessionTimeout;
      if (sessionTimeout) {
        this.setSessionTimeout(false);
      } else {
        const permissionStore = usePermissionStore();

        // 动态路由加载（首次）
        if (!permissionStore.isDynamicAddedRoute) {
          const routes = await permissionStore.buildRoutesAction();
          [...routes, PAGE_NOT_FOUND_ROUTE].forEach((route) => {
            router.addRoute(route as unknown as RouteRecordRaw);
          });
          // 记录动态路由加载完成
          permissionStore.setDynamicAddedRoute(true);
        }

        goHome && (await router.replace(userInfo?.HomePath || PageEnum.BASE_HOME));
      }
      return userInfo;
    },
    /**
     * 获取用户信息操作
     * @returns 用户信息
     */
    async getUserInfoAction(): Promise<UserInfo | null> {
      const userInfo = await this.refreshUser();
      return userInfo;
    },
    /**
     * @description: 注销（logout）
     */
    async logout(goLogin = false) {
      if (this.getAccessToken) {
        try {
          await logout();
        } catch (ex) {
          console.log(`注销失败：${ex?.message}`);
        }
      }
      await this.setToken(undefined);
      this.setSessionTimeout(false);
      this.setUserInfo(null);
      if (goLogin) {
        // 直接回登陆页
        router.replace(PageEnum.BASE_LOGIN);
      } else {
        // 回登陆页带上当前路由地址
        router.replace({
          path: PageEnum.BASE_LOGIN,
          query: {
            redirect: encodeURIComponent(router.currentRoute.value.fullPath),
          },
        });
      }
      await this.refreshAuthInfo();
    },
    /** 编辑用户信息 */
    async profileEdit(
      params: ProfileEditDto & { mode?: ErrorMessageMode },
    ): Promise<UserInfo | null> {
      const { createMessage } = useMessage();
      const { mode, ...profileEditParams } = params;
      const ajaxResult = await profileEdit(profileEditParams, mode);
      if (ajaxResult.Succeeded) {
        const userInfo = await this.refreshUser();
        return userInfo;
      } else {
        createMessage.error(ajaxResult.Content);
        // throw new Error(ajaxResult.Content);
      }
      return null;
    },
    /** 修改密码 */
    async changePassword(
      params: ChangePasswordDto & { mode?: ErrorMessageMode },
    ): Promise<UserInfo | null> {
      const { createMessage } = useMessage();
      const { mode, ...changePasswordParams } = params;
      const ajaxResult = await changePassword(changePasswordParams, mode);
      if (ajaxResult.Succeeded) {
        const userInfo = await this.refreshUser();
        return userInfo;
      } else {
        createMessage.error(ajaxResult.Content);
        // throw new Error(ajaxResult.Content);
      }
      return null;
    },
    /** 用户邮箱变更 */
    async changeUserEmail(
      params: EmailEditDto & { mode?: ErrorMessageMode },
    ): Promise<UserInfo | null> {
      const { createMessage } = useMessage();
      const { mode, ...emailEditParams } = params;
      const ajaxResult = await changeUserEmail(emailEditParams, mode);
      if (ajaxResult.Succeeded) {
        const userInfo = await this.refreshUser();
        return userInfo;
      } else {
        createMessage.error(ajaxResult.Content);
        // throw new Error(ajaxResult.Content);
      }
      return null;
    },
    /** 用户手机变更 */
    async changeUserPhone(
      params: PhoneEditDto & { mode?: ErrorMessageMode },
    ): Promise<UserInfo | null> {
      const { createMessage } = useMessage();
      const { mode, ...phoneEditParams } = params;
      const ajaxResult = await changeUserPhone(phoneEditParams, mode);
      if (ajaxResult.Succeeded) {
        const userInfo = await this.refreshUser();
        return userInfo;
      } else {
        createMessage.error(ajaxResult.Content);
        // throw new Error(ajaxResult.Content);
      }
      return null;
    },
    /**
     * 登录完成后程序处理
     * @param jsonWebToken JwtToken模型
     */
    async loginEnd(jsonWebToken: JsonWebToken) {
      // 设置Token
      await this.setToken(jsonWebToken);
      //初始化SignalR连接
      await this.connectSignalRHub();
    },
    /** 刷新用户信息 */
    async refreshUser(): Promise<UserInfo | null> {
      const profileDto = await profile();
      if (profileDto === undefined || profileDto === null) {
        removeAuthCache(USER_INFO_KEY);
        return null;
      }
      const userInfo: UserInfo = {
        UserId: profileDto.UserId,
        UserName: profileDto.UserName,
        NickName: profileDto.NickName,
        Email: profileDto.Email,
        PhoneNumber: profileDto.PhoneNumber,

        Avatar: profileDto.Avatar,
        Signature: profileDto.Signature,

        Gender: profileDto.Gender,
        Birthday: profileDto.Birthday,
        BloodType: profileDto.BloodType,
        Tag: profileDto.Tag,
        Title: profileDto.Title,
        Address: profileDto.Address,
        Profile: profileDto.Profile,
        Sign: profileDto.Sign,
        Remark: profileDto.Remark,

        HomePath: profileDto.HomePath,

        ChineseBirthday: profileDto.ChineseBirthday,
        Age: profileDto.Age,
        ZodiacSign: profileDto.ZodiacSign,
        StarSign: profileDto.StarSign,

        IsAdmin: profileDto.IsAdmin,

        IsRefreshNext: profileDto.IsRefreshNext,

        Roles: profileDto.Roles,

        CurrentOrganization: profileDto.CurrentOrganization,
        CurrentDepartment: profileDto.CurrentDepartment,

        ExtendData: profileDto.ExtendData,
      };
      //处理用户头像
      if (userInfo.Avatar === undefined || userInfo.Avatar === null || userInfo.Avatar === '') {
        userInfo.Avatar = headerImg;
      }
      // userInfo.Avatar = handleFileLink(profileDto.Avatar);
      //设置用户
      this.setUserInfo(userInfo);
      // 刷新授权信息
      await this.refreshAuthInfo();

      // TODO:获取及设置系统偏好设置项（可以通过远程Api的方式获取，建议封装成独立方法）
      setPreferenceInfo({
        Id: '1',
        OrganizationId: userInfo?.CurrentOrganization?.Id,
        Initialized: true,
        CEO: '',
        CFO: '',
        MainCurrencyId: 'CNY',
        SysCurrencyId: 'CNY',
        ExchangeQuotation: ExchangeQuotationEnum.DirectQuotation,
        QuantityAccuracy: 4,
        PriceAccuracy: 6,
        AmountAccuracy: 2,
        RateAccuracy: 4,
        PercentageAccuracy: 4,
        MeasureAccuracy: 4,
        CompanyName: userInfo?.CurrentOrganization?.Name ? userInfo.CurrentOrganization.Name : '',
        TaxpayerNumber: '',
        CompanyAddr: '',
        CompanyTel: '',
        CompanyBank: '',
        CompBakAccount: '',
      });

      return userInfo;
    },
    /** 刷新授权信息 */
    async refreshAuthInfo() {
      //! 注：后端采用授权编码模式，前端考虑到后续的升级兼容，采用路由映射模式，并且在手动拉取后端授权码后赋值给角色属性，用于权限控制。
      const appStore = useAppStore();
      const permissionMode = appStore.getProjectConfig.permissionMode;
      const { refreshMenu } = usePermission();
      //#region "角色处理"
      // // 获取角色
      // const roleInfoList = this.getUserInfo?.Roles?.map((m) => m.Id) || [];
      // const roleList = this.getRoleList || [];
      // //对比字符串
      // const roleInfoListString = roleInfoList.sort().toString();
      // const roleListString = roleList.sort().toString();
      // if (roleListString !== roleInfoListString) {
      //   // 设置角色
      //   this.setRoleList(roleInfoList);
      //   // 刷新菜单数据（refresh menu data）
      //   // switch (permissionMode) {
      //   //   case PermissionModeEnum.ROLE:
      //   //   case PermissionModeEnum.ROUTE_MAPPING:
      //   //     await refreshMenu(false);
      //   //     break;
      //   // }
      // }
      //#endregion

      //#region "权限代码处理"
      const permissionStore = usePermissionStore();
      //获取权限代码
      const authInfoList = (await getAuthInfo()) || [];
      const authList = permissionStore.getPermCodeList || [];
      //对比字符串
      const authInfoListString = authInfoList.sort().toString();
      const authListString = authList.sort().toString();
      if (authListString !== authInfoListString) {
        // 设置角色
        this.setRoleList(authInfoList);
        // 设置权限代码列表
        permissionStore.setPermCodeList(authInfoList);
        // 刷新菜单数据（refresh menu data）
        switch (permissionMode) {
          case PermissionModeEnum.BACK:
          case PermissionModeEnum.ROLE:
          case PermissionModeEnum.ROUTE_MAPPING:
            await refreshMenu(false);
            break;
        }
      }
      //#endregion
    },
    /**
     * 尝试刷新AccessToken和RefreshToken，检测AccessToken有效期，如过期则使用RefreshToken来刷新
     * @param mode 错误消息模型
     */
    async tryRefreshToken(mode: ErrorMessageMode = 'none') {
      const jsonWebToken = this.getToken;
      if (jsonWebToken) {
        // const diff = Math.round((jsonWebToken.AccessTokenExpiresUtc - new Date().valueOf()) / 1000);
        const seconds = new Date().valueOf();
        const accessTokenExpiresUtc = jsonWebToken.AccessTokenExpiresUtc
          ? Number(jsonWebToken.AccessTokenExpiresUtc)
          : 0;
        const diff = (accessTokenExpiresUtc - seconds) / 1000;
        // console.log('tryRefreshToken', { accessTokenExpiresUtc, seconds, diff });
        // 检测Token的有效期和当前时间相差小于300秒时，执行刷新Token，否则跳过
        if (diff > 300) {
          return;
        }
        const refreshToken = jsonWebToken.RefreshToken;
        if (refreshToken) {
          await this.refreshToken(refreshToken, mode);
        }
      }
    },
    /**
     * 使用现在的RefreshToken刷新新的AccessToken与RefreshToken
     * @param refreshToken 现有的RefreshToken
     * @param mode 错误消息模型
     */
    async refreshToken(
      refreshToken: string,
      mode: ErrorMessageMode = 'none',
    ): Promise<UserInfo | null> {
      //const { createMessage } = useMessage();
      try {
        // 使用RefreshToken刷新AccessToken
        const dto: TokenDto = { RefreshToken: refreshToken, GrantType: 'refresh_token' };
        const ajaxResult = await token(dto, mode);
        const jsonWebToken = ajaxResult.Data as JsonWebToken;
        await this.loginEnd(jsonWebToken);

        // get user info
        const userInfo = await this.getUserInfoAction();
        return userInfo;
      } catch (error) {
        //createMessage.error(error?.message);
        return null;
      }
    },
    /** 连接SignalR集线器 */
    async connectSignalRHub() {
      if (this.signalrHub !== null) {
        //如果已经连接，则返回
        if (
          this.signalrHub.state === signalR.HubConnectionState.Connected ||
          this.signalrHub.state === signalR.HubConnectionState.Connecting ||
          this.signalrHub.state === signalR.HubConnectionState.Reconnecting
        ) {
          return;
        } else {
          this.signalrHub = null;
        }
      }

      let signalrHubUrl = '';
      const { signalrUrl, signalrPrefix } = useGlobSetting();
      if (signalrPrefix !== undefined && signalrPrefix !== null && signalrPrefix !== '') {
        signalrHubUrl = signalrPrefix.startsWith('/') ? signalrPrefix : `/${signalrPrefix}`;
      }
      if (signalrUrl !== undefined && signalrUrl !== null && signalrUrl !== '') {
        signalrHubUrl = `${signalrUrl}${signalrHubUrl}`;
      }
      //SignalR
      this.signalrHub = new signalR.HubConnectionBuilder()
        //服务器地址：本地站点可以直接写“/xxx”。JWT验证码：不带Bearer
        .withUrl(signalrHubUrl, { accessTokenFactory: () => this.getAccessToken })
        //默认不会自动重连，需手动调用 withAutomaticReconnect
        //如果不带任何参数，withAutomaticReconnect 会配置客户端在每一次重连尝试之前，分别等待0，2，10，30秒，如果四次重连均失败，那么连接便会停止。
        //如果配置了自动重连，在开始每一次重连尝试之前，HubConnection 都会变为 HubConnectionState.Reconnecting 状态并触发它的onreconnecting 回调。
        //而如果没有配置HubConnection 为自动重连，此时（连接断开时）HubConnection 的状态会变为Disconnected 并触发它的onclose 回调。
        //这就提供了一个时机来警告用户连接已经丢失，并禁用掉相关的UI元素。
        .withAutomaticReconnect({
          nextRetryDelayInMilliseconds: (retryContext) => {
            if (retryContext.elapsedMilliseconds < 60000) {
              // 如果到目前为止我们重新连接的时间不到60秒，在下一次重新连接尝试之前的0到10秒之间。
              return Math.random() * 10000;
            } else {
              // 如果到目前为止重新连接的时间超过60秒，请停止重新连接。
              return null;
            }
          },
        })
        .build();

      //#region "客户端心跳机制在服务端发布模式下好像有问题，导致异常断开，先注释备查"
      // # SignalR服务器活动超时（毫秒）。 如果服务器未在此时间间隔内发送消息，则客户端会将服务器视为断开连接，并触发 onclose 事件。默认超时值为30000毫秒（30秒）。
      // # 此值必须足够大，以便从服务器发送 ping 消息 ，并在超时间隔内由客户端接收该消息。 建议值至少为服务器的 KeepAliveInterval 值的两倍，以允许 ping 到达的时间。
      // if (signalrServerTimeout && signalrServerTimeout > 0) {
      //   this.signalrHub.serverTimeoutInMilliseconds = signalrServerTimeout;
      // }

      // # SignalR确定客户端发送 ping 消息的间隔。 如果从客户端发送任何消息，则会将计时器重置为间隔的开始时间。默认值为15000毫秒（15秒）。
      // # 如果客户端未在服务器上设置的 ClientTimeoutInterval 中发送消息，则服务器会将客户端视为已断开连接。
      // # ping最多与服务器ping一样频繁。如果服务器每5秒ping一次，则低于5的值将每5秒ping一次。
      // if (signalrKeepAliveInterval && signalrKeepAliveInterval > 0) {
      //   this.signalrHub.keepAliveIntervalInMilliseconds = signalrKeepAliveInterval;
      // }
      //#endregion

      // this.signalrHub.onreconnecting(async (error) => {
      //   console.log('监听到正在连接SignalR', error);
      // });
      // this.signalrHub.onreconnected(async (connectionId) => {
      //   console.log('监听到连接SignalR成功', connectionId);
      // });
      this.signalrHub.onclose((error) => {
        console.log('监听到SignalR客户端连接关闭', error || '');
        this.signalrHub = null;
      });

      // this.signalrHub.on('AAA', (msg: string) => {
      //   const { createMessage } = useMessage();
      //   createMessage.success(msg);
      // });

      //如果已经断开连接，则连接。
      try {
        if (
          this.signalrHub.state === signalR.HubConnectionState.Disconnected ||
          this.signalrHub.state === signalR.HubConnectionState.Disconnecting
        ) {
          await this.signalrHub.start();
        }
        // this.signalrHub.on('BBB', (msg: string) => {
        //   const { createMessage } = useMessage();
        //   createMessage.success(msg);
        // });
      } catch (error: any) {
        console.log('连接SignalR失败', error?.message);
        this.signalrHub = null;
      }
    },
    /** 断开连接SignalR集线器 */
    async disconnectSignalRHub() {
      //SignalR
      if (this.signalrHub !== null) {
        //如果已经连接，则断开
        if (
          this.signalrHub.state === signalR.HubConnectionState.Connected ||
          this.signalrHub.state === signalR.HubConnectionState.Connecting ||
          this.signalrHub.state === signalR.HubConnectionState.Reconnecting
        ) {
          await this.signalrHub.stop();
        }
      }
      this.signalrHub = null;
    },
  },
});

/** 需要在设置之外使用（Need to be used outside the setup） */
export function useIdentityStoreWithOut() {
  return useIdentityStore(store);
}
